home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / CapturePanel.c < prev    next >
C/C++ Source or Header  |  1995-09-28  |  21KB  |  881 lines
  1. /*
  2. **    CapturePanel.c
  3. **
  4. **    Editing panel for log file, buffer and capture configuration
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LOGACTIONS, GAD_LOGFILE, GAD_SELECT_LOGFILE, GAD_LOGCALLS, GAD_CALL_LOGFILE,GAD_SELECT_CALL_LOGFILE,
  13.         GAD_MAX_BUFFER_SIZE,GAD_BUFFER_ENABLED,GAD_BUFFER_PATH,GAD_SELECT_BUFFER_PATH,
  14.         GAD_CONNECT_AUTO_CAPTURE, GAD_AUTOCAPTURE_DATE, GAD_CAPTURE_FILTER, GAD_CONVERT_CHARS,
  15.         GAD_CAPTURE_PATH, GAD_SELECT_CAPTURE_PATH, GAD_OPEN_BUFFER_WINDOW, GAD_BUFFER_MODE,
  16.         GAD_REMEMBER_WINDOW_POS,GAD_OPEN_BUFFER_SCREEN,GAD_REMEMBER_SCREEN_POS,GAD_SEARCH_HISTORY,
  17.         GAD_SCREENMODE,GAD_BUFFERSCREEN_POSITION,GAD_BUFFERWIDTH,GAD_USE, GAD_CANCEL, GAD_DEFAULT,
  18.         GAD_PAGER, GAD_PAGEGROUP,
  19.     };
  20.  
  21. STATIC BYTE  __regargs
  22. SelectDisplayMode(struct Window *Window,ULONG *CurrentMode,struct Configuration *Config)
  23. {
  24.     BYTE Success = FALSE;
  25.  
  26.     if(AslBase -> lib_Version < 38)
  27.     {
  28.         struct List    *ModeList;
  29.         LONG         Index;
  30.  
  31.         if(ModeList = BuildModeList(&Index,*CurrentMode,NULL))
  32.         {
  33.             struct LayoutHandle *Handle;
  34.  
  35.             if(Handle = LT_CreateHandleTags(Window -> WScreen,
  36.                 LH_LocaleHook,    &LocaleHook,
  37.             TAG_DONE))
  38.             {
  39.                 struct Window *LocalWindow;
  40.  
  41.                 LT_New(Handle,
  42.                     LA_Type,    VERTICAL_KIND,
  43.                 TAG_DONE);
  44.                 {
  45.                     LT_New(Handle,
  46.                         LA_Type,    VERTICAL_KIND,
  47.                     TAG_DONE);
  48.                     {
  49.                         LONG MaxWidth = -1,MaxHeight = 0,Len;
  50.                         struct Node *Node;
  51.  
  52.                         for(Node = ModeList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  53.                         {
  54.                             Len = strlen(Node -> ln_Name);
  55.  
  56.                             if(Len > MaxWidth)
  57.                                 MaxWidth = Len;
  58.  
  59.                             MaxHeight++;
  60.                         }
  61.  
  62.                         MaxHeight++;
  63.  
  64.                         LT_New(Handle,
  65.                             LA_Type,    LISTVIEW_KIND,
  66.                             LA_LabelID,    MSG_V36_0160,
  67.                             GTLV_Labels,    ModeList,
  68.                             LA_LONG,    &Index,
  69.                             LALV_CursorKey,    TRUE,
  70.                             LALV_Link,    NIL_LINK,
  71.                             LALV_MaxGrowY,    MaxHeight,
  72.                             LALV_ResizeY,    TRUE,
  73.                             LA_Lines,    MaxHeight > 10 ? 10 : MaxHeight,
  74.                             LA_Chars,    MaxWidth,
  75.                             LA_CursorKey,    TRUE,
  76.                         TAG_DONE);
  77.  
  78.                         LT_EndGroup(Handle);
  79.                     }
  80.  
  81.                     LT_New(Handle,
  82.                         LA_Type,VERTICAL_KIND,
  83.                     TAG_DONE);
  84.                     {
  85.                         LT_New(Handle,
  86.                             LA_Type,    XBAR_KIND,
  87.                             LAXB_FullSize,    TRUE,
  88.                         TAG_DONE);
  89.  
  90.                         LT_EndGroup(Handle);
  91.                     }
  92.  
  93.                     LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  94.                         LAGR_SameSize,    TRUE,
  95.                         LAGR_Spread,    TRUE,
  96.                     TAG_DONE);
  97.                     {
  98.                         LT_New(Handle,
  99.                             LA_Type,    BUTTON_KIND,
  100.                             LA_LabelID,    MSG_GLOBAL_USE_GAD,
  101.                             LA_ID,        GAD_USE,
  102.                             LABT_ReturnKey,    TRUE,
  103.                             LABT_ExtraFat,    TRUE,
  104.                         TAG_DONE);
  105.  
  106.                         LT_New(Handle,
  107.                             LA_Type,    BUTTON_KIND,
  108.                             LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  109.                             LA_ID,        GAD_CANCEL,
  110.                             LABT_EscKey,    TRUE,
  111.                             LABT_ExtraFat,    TRUE,
  112.                         TAG_DONE);
  113.  
  114.                         LT_EndGroup(Handle);
  115.                     }
  116.  
  117.                     LT_EndGroup(Handle);
  118.                 }
  119.  
  120.                 if(LocalWindow = LT_Build(Handle,
  121.                     LAWN_TitleID,        MSG_V36_0161,
  122.                     LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  123.                     LAWN_HelpHook,        &GuideHook,
  124.                     LAWN_Parent,        Window,
  125.                     WA_DepthGadget,        TRUE,
  126.                     WA_CloseGadget,        TRUE,
  127.                     WA_DragBar,        TRUE,
  128.                     WA_RMBTrap,        TRUE,
  129.                     WA_Activate,        TRUE,
  130.                     WA_SimpleRefresh,    TRUE,
  131.                 TAG_DONE))
  132.                 {
  133.                     struct IntuiMessage    *Message;
  134.                     BOOL             Done = FALSE;
  135.                     ULONG             MsgClass;
  136.                     struct Gadget        *MsgGadget;
  137.                     LONG             i;
  138.                     struct ModeNode        *ModeNode;
  139.  
  140.                     do
  141.                     {
  142.                         WaitPort(LocalWindow -> UserPort);
  143.  
  144.                         while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  145.                         {
  146.                             MsgClass    = Message -> Class;
  147.                             MsgGadget    = (struct Gadget *)Message -> IAddress;
  148.  
  149.                             LT_ReplyIMsg(Message);
  150.  
  151.                             if(MsgClass == IDCMP_CLOSEWINDOW)
  152.                                 Done = TRUE;
  153.  
  154.                             if(MsgClass == IDCMP_GADGETUP)
  155.                             {
  156.                                 switch(MsgGadget -> GadgetID)
  157.                                 {
  158.                                     case GAD_USE:
  159.  
  160.                                         for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0 ; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  161.                                         {
  162.                                             if(Index == i)
  163.                                             {
  164.                                                 *CurrentMode = ModeNode -> DisplayID;
  165.  
  166.                                                 break;
  167.                                             }
  168.                                         }
  169.  
  170.                                         Success = Done = TRUE;
  171.                                         break;
  172.  
  173.                                     case GAD_CANCEL:
  174.  
  175.                                         Done = TRUE;
  176.                                         break;
  177.                                 }
  178.                             }
  179.  
  180.                             if(MsgClass == IDCMP_IDCMPUPDATE)
  181.                             {
  182.                                 for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  183.                                 {
  184.                                     if(Index == i)
  185.                                     {
  186.                                         *CurrentMode = ModeNode -> DisplayID;
  187.  
  188.                                         Success = Done = TRUE;
  189.  
  190.                                         LT_PressButton(Handle,GAD_USE);
  191.  
  192.                                         break;
  193.                                     }
  194.                                 }
  195.                             }
  196.                         }
  197.                     }
  198.                     while(!Done);
  199.                 }
  200.  
  201.                 LT_DeleteHandle(Handle);
  202.             }
  203.  
  204.             DeleteList(ModeList);
  205.         }
  206.     }
  207.     else
  208.     {
  209.         struct ScreenModeRequester    *Request;
  210.         struct TagItem             DimensionTags[5];
  211.  
  212.         if(Request = (struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  213.             ASLSM_Window,        Window,
  214.             ASLSM_InitialDisplayID,    *CurrentMode,
  215.             ASLSM_PrivateIDCMP,    TRUE,
  216.         TAG_MORE,GetDimensionTags(Window,DimensionTags)))
  217.         {
  218.             if(AslRequest(Request,NULL))
  219.             {
  220.                 PutDimensionTags(Window,Request -> sm_LeftEdge,Request -> sm_TopEdge,Request -> sm_Width,Request -> sm_Height);
  221.  
  222.                 *CurrentMode = Request -> sm_DisplayID;
  223.  
  224.                 Success = TRUE;
  225.             }
  226.  
  227.             FreeAslRequest(Request);
  228.         }
  229.     }
  230.  
  231.     return(Success);
  232. }
  233.  
  234. BYTE __regargs
  235. CapturePanel(struct Configuration *Config,BYTE *Default)
  236. {
  237.     STATIC LONG PageTitleID[7] =
  238.     {
  239.         MSG_V36_0008,
  240.         MSG_V36_0011,
  241.         MSG_V36_0009,
  242.         MSG_V36_0013,
  243.         MSG_V36_0014,
  244.         MSG_CAPTUREPANEL_SERVICES_TXT,
  245.         -1
  246.     };
  247.  
  248.     STATIC BYTE InitialPage = 0;
  249.  
  250.     struct LayoutHandle    *Handle;
  251.     BYTE             Cancel = FALSE;
  252.  
  253.     SaveConfig(Config,PrivateConfig);
  254.  
  255.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  256.         LH_LocaleHook,    &LocaleHook,
  257.         LH_ExitFlush,    FALSE,
  258.     TAG_DONE))
  259.     {
  260.         struct Window    *PanelWindow;
  261.         BYTE         OpenBufferWindow = Config -> CaptureConfig -> OpenBufferWindow & 0xF,
  262.                  OpenBufferScreen = Config -> CaptureConfig -> OpenBufferScreen & 0xF;
  263.         UBYTE         ModeName[DISPLAYNAMELEN + 1];
  264.         ULONG         DisplayMode;
  265.  
  266.         DisplayMode = Config -> CaptureConfig -> BufferScreenMode;
  267.  
  268.         if(ModeNotAvailable(DisplayMode))
  269.         {
  270.             if(Config && Config -> ScreenConfig)
  271.                 DisplayMode = Config -> ScreenConfig -> DisplayMode;
  272.             else
  273.                 DisplayMode = INVALID_ID;
  274.         }
  275.  
  276.         if(ModeNotAvailable(DisplayMode))
  277.         {
  278.             struct Screen *PubScreen = LockPubScreen(NULL);
  279.  
  280.             if(PubScreen)
  281.             {
  282.                 DisplayMode = GetVPModeID(&PubScreen -> ViewPort);
  283.  
  284.                 UnlockPubScreen(NULL,PubScreen);
  285.             }
  286.             else
  287.                 DisplayMode = DEFAULT_MONITOR_ID | HIRES_KEY;
  288.         }
  289.  
  290.         strcpy(ModeName,GetModeName(DisplayMode));
  291.  
  292.         LT_New(Handle,
  293.             LA_Type,    VERTICAL_KIND,
  294.         TAG_DONE);
  295.         {
  296.             LT_New(Handle,
  297.                 LA_Type,VERTICAL_KIND,
  298.             TAG_DONE);
  299.             {
  300.                 LT_New(Handle,
  301.                     LA_Type,    TAB_KIND,
  302.                     LA_ID,        GAD_PAGER,
  303.                     LA_LabelID,    MSG_XFER_PAGE_TXT,
  304.                     LACY_LabelTable,PageTitleID,
  305.                     LACY_AutoPageID,GAD_PAGEGROUP,
  306.                     LACY_TabKey,    TRUE,
  307.                     LA_BYTE,    &InitialPage,
  308.                     LATB_FullWidth,    TRUE,
  309.                 TAG_DONE);
  310.  
  311.                 LT_EndGroup(Handle);
  312.             }
  313.  
  314.             LT_New(Handle,
  315.                 LA_Type,    VERTICAL_KIND,
  316.                 LA_ID,        GAD_PAGEGROUP,
  317.                 LAGR_ActivePage,InitialPage,
  318.             TAG_DONE);
  319.             {
  320.                 LT_New(Handle,
  321.                     LA_Type,    VERTICAL_KIND,
  322.                 TAG_DONE);
  323.                 {
  324.                     LT_New(Handle,
  325.                         LA_LabelID,    MSG_CAPTUREPANEL_LOG_ACTIONS_GAD,
  326.                         LA_Type,    CHECKBOX_KIND,
  327.                         LA_ID,        GAD_LOGACTIONS,
  328.                         LA_BYTE,    &Config -> CaptureConfig -> LogActions,
  329.                     TAG_DONE);
  330.  
  331.                     LT_New(Handle,
  332.                         LA_LabelID,    MSG_CAPTUREPANEL_LOGFILE_GAD,
  333.                         LA_Type,    STRING_KIND,
  334.                         LA_ID,        GAD_LOGFILE,
  335.                         LA_Chars,    20,
  336.                         LA_STRPTR,    Config -> CaptureConfig -> LogFileName,
  337.                         LAST_Picker,    TRUE,
  338.                         GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  339.                     TAG_DONE);
  340.  
  341.                     LT_New(Handle,
  342.                         LA_Type,    XBAR_KIND,
  343.                     TAG_DONE);
  344.  
  345.                     LT_New(Handle,
  346.                         LA_LabelID,    MSG_CAPTUREPANEL_LOG_CALLS_GAD,
  347.                         LA_Type,    CHECKBOX_KIND,
  348.                         LA_ID,        GAD_LOGCALLS,
  349.                         LA_BYTE,    &Config -> CaptureConfig -> LogCall,
  350.                     TAG_DONE);
  351.  
  352.                     LT_New(Handle,
  353.                         LA_LabelID,    MSG_CAPTUREPANEL_CALL_LOGFILE_GAD,
  354.                         LA_Type,    STRING_KIND,
  355.                         LA_ID,        GAD_CALL_LOGFILE,
  356.                         LA_STRPTR,    Config -> CaptureConfig -> CallLogFileName,
  357.                         LAST_Picker,    TRUE,
  358.                         GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  359.                     TAG_DONE);
  360.  
  361.                     LT_EndGroup(Handle);
  362.                 }
  363.  
  364.                 LT_New(Handle,
  365.                     LA_Type,    VERTICAL_KIND,
  366.                 TAG_DONE);
  367.                 {
  368.                     LT_New(Handle,
  369.                         LA_Type,    VERTICAL_KIND,
  370.                     TAG_DONE);
  371.                     {
  372.                         LT_New(Handle,
  373.                             LA_LabelID,    MSG_CAPTUREPANEL_CONNECT_AUTO_CAPTURE_GAD,
  374.                             LA_Type,    CHECKBOX_KIND,
  375.                             LA_ID,        GAD_CONNECT_AUTO_CAPTURE,
  376.                             LA_BYTE,    &Config -> CaptureConfig -> ConnectAutoCapture,
  377.                         TAG_DONE);
  378.  
  379.                         LT_New(Handle,
  380.                             LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_FILTER_ENABLED_GAD,
  381.                             LA_Type,    CHECKBOX_KIND,
  382.                             LA_ID,        GAD_CAPTURE_FILTER,
  383.                             LA_BYTE,    &Config -> CaptureConfig -> CaptureFilterMode,
  384.                         TAG_DONE);
  385.  
  386.                         LT_New(Handle,
  387.                             LA_LabelID,    MSG_CONVERT_CHARACTERS_GAD,
  388.                             LA_Type,    CHECKBOX_KIND,
  389.                             LA_BYTE,    &Config -> CaptureConfig -> ConvertChars,
  390.                             GA_Disabled,    !Config -> CaptureConfig -> CaptureFilterMode,
  391.                             LA_ID,        GAD_CONVERT_CHARS,
  392.                         TAG_DONE);
  393.  
  394.                         LT_EndGroup(Handle);
  395.                     }
  396.  
  397.                     LT_New(Handle,
  398.                         LA_Type,    VERTICAL_KIND,
  399.                     TAG_DONE);
  400.                     {
  401.                         LT_New(Handle,
  402.                             LA_LabelID,    MSG_CAPTUREPANEL_CREATION_DATE_GAD,
  403.                             LA_Type,    CYCLE_KIND,
  404.                             LA_ID,        GAD_AUTOCAPTURE_DATE,
  405.                             LA_BYTE,    &Config -> CaptureConfig -> AutoCaptureDate,
  406.                             LACY_FirstLabel,MSG_CAPTUREPANEL_APPEND_DATE_TXT,
  407.                             LACY_LastLabel,    MSG_CAPTUREPANEL_WRITE_DATE_TO_FILE_TXT,
  408.                         TAG_DONE);
  409.  
  410.                         LT_New(Handle,
  411.                             LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_PATH_GAD,
  412.                             LA_Type,    STRING_KIND,
  413.                             LA_ID,        GAD_CAPTURE_PATH,
  414.                             LA_Chars,    20,
  415.                             LA_STRPTR,    Config -> CaptureConfig -> CapturePath,
  416.                             LAST_Picker,    TRUE,
  417.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  418.                             LA_ExtraSpace,    TRUE,
  419.                         TAG_DONE);
  420.  
  421.                         LT_EndGroup(Handle);
  422.                     }
  423.  
  424.                     LT_EndGroup(Handle);
  425.                 }
  426.  
  427.                 LT_New(Handle,
  428.                     LA_Type,    VERTICAL_KIND,
  429.                 TAG_DONE);
  430.                 {
  431.                     LT_New(Handle,
  432.                         LA_LabelID,        MSG_CAPTUREPANEL_BUFFER_ENABLED_GAD,
  433.                         LA_Type,        CHECKBOX_KIND,
  434.                         LA_ID,            GAD_BUFFER_ENABLED,
  435.                         LA_BYTE,        &Config -> CaptureConfig -> BufferEnabled,
  436.                     TAG_DONE);
  437.  
  438.                     LT_New(Handle,
  439.                         LA_LabelID,        MSG_CAPTUREPANEL_MAX_BUFFER_SIZE_GAD,
  440.                         LA_Type,        INTEGER_KIND,
  441.                         LA_ID,            GAD_MAX_BUFFER_SIZE,
  442.                         LA_LONG,        &Config -> CaptureConfig -> MaxBufferSize,
  443.                         LAIN_UseIncrementers,    TRUE,
  444.                         LAIN_Min,        0,
  445.                     TAG_DONE);
  446.  
  447.                     LT_New(Handle,
  448.                         LA_LabelID,        MSG_CAPTUREPANEL_BUFFER_PATH_GAD,
  449.                         LA_Type,        STRING_KIND,
  450.                         LA_ID,            GAD_BUFFER_PATH,
  451.                         LA_STRPTR,        Config -> CaptureConfig -> BufferPath,
  452.                         LAST_Picker,        TRUE,
  453.                         LA_Chars,        20,
  454.                         GTST_MaxChars,        MAX_FILENAME_LENGTH - 1,
  455.                     TAG_DONE);
  456.  
  457.                     LT_New(Handle,
  458.                         LA_LabelID,        MSG_CAPTUREPANEL_BUFFER_LINE_WIDTH_GAD,
  459.                         LA_Type,        SliderType,
  460.                         LA_ID,            GAD_BUFFERWIDTH,
  461.                         LA_UBYTE,        &Config -> CaptureConfig -> BufferWidth,
  462.                         GTSL_Min,        80,
  463.                         GTSL_Max,        BUFFER_LINE_MAX,
  464.                         GTSL_LevelFormat,    "%3ld",
  465.                     TAG_DONE);
  466.  
  467.                     LT_New(Handle,
  468.                         LA_LabelID,        MSG_BUFFER_OPERATION_MODE_TXT,
  469.                         LA_Type,        CYCLE_KIND,
  470.                         LA_ID,            GAD_BUFFER_MODE,
  471.                         LA_BYTE,        &Config -> CaptureConfig -> BufferMode,
  472.                         LACY_FirstLabel,    MSG_BUFFER_MODE1_TXT,
  473.                         LACY_LastLabel,        MSG_BUFFER_MODE2_TXT,
  474.                     TAG_DONE);
  475.  
  476.                     LT_EndGroup(Handle);
  477.                 }
  478.  
  479.                 LT_New(Handle,
  480.                     LA_Type,    VERTICAL_KIND,
  481.                 TAG_DONE);
  482.                 {
  483.                     LT_New(Handle,
  484.                         LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_WINDOW_GAD,
  485.                         LA_Type,    MX_KIND,
  486.                         LA_ID,        GAD_OPEN_BUFFER_WINDOW,
  487.                         LA_BYTE,    &OpenBufferWindow,
  488.                         LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  489.                         LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  490.                     TAG_DONE);
  491.  
  492.                     LT_New(Handle,
  493.                         LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_WINDOW_GAD,
  494.                         LA_Type,    CHECKBOX_KIND,
  495.                         LA_ID,        GAD_REMEMBER_WINDOW_POS,
  496.                         LA_BYTE,    &Config -> CaptureConfig -> RememberBufferWindow,
  497.                         LA_ExtraSpace,    TRUE,
  498.                     TAG_DONE);
  499.  
  500.                     LT_EndGroup(Handle);
  501.                 }
  502.  
  503.                 LT_New(Handle,
  504.                     LA_Type,    VERTICAL_KIND,
  505.                 TAG_DONE);
  506.                 {
  507.                     LT_New(Handle,
  508.                         LA_Type,    VERTICAL_KIND,
  509.                     TAG_DONE);
  510.                     {
  511.                         LT_New(Handle,
  512.                             LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_SCREEN_GAD,
  513.                             LA_Type,    MX_KIND,
  514.                             LA_ID,        GAD_OPEN_BUFFER_SCREEN,
  515.                             LA_BYTE,    &OpenBufferScreen,
  516.                             LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  517.                             LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  518.                         TAG_DONE);
  519.  
  520.                         LT_New(Handle,
  521.                             LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_SCREEN_GAD,
  522.                             LA_Type,    CHECKBOX_KIND,
  523.                             LA_ID,        GAD_REMEMBER_SCREEN_POS,
  524.                             LA_BYTE,    &Config -> CaptureConfig -> RememberBufferScreen,
  525.                             LA_ExtraSpace,    TRUE,
  526.                         TAG_DONE);
  527.  
  528.                         LT_New(Handle,
  529.                             LA_Type,    XBAR_KIND,
  530.                         TAG_DONE);
  531.  
  532.                         LT_New(Handle,
  533.                             LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_SCREEN_POSITION_GAD,
  534.                             LA_Type,    MX_KIND,
  535.                             LA_ID,        GAD_BUFFERSCREEN_POSITION,
  536.                             LA_BYTE,    &Config -> CaptureConfig -> BufferScreenPosition,
  537.                             LAMX_FirstLabel,MSG_CAPTUREPANEL_LEFT_TXT,
  538.                             LAMX_LastLabel,    MSG_CAPTUREPANEL_RIGHT_TXT,
  539.                         TAG_DONE);
  540.  
  541.                         LT_New(Handle,
  542.                             LA_Type,    XBAR_KIND,
  543.                         TAG_DONE);
  544.  
  545.                         LT_EndGroup(Handle);
  546.                     }
  547.  
  548.                     LT_New(Handle,
  549.                         LA_Type,    VERTICAL_KIND,
  550.                     TAG_DONE);
  551.                     {
  552.                         LT_New(Handle,
  553.                             LA_Type,    TEXT_KIND,
  554.                             LA_LabelID,    MSG_SCREENPANEL_CURRENT_DISPLAY_MODE_GAD,
  555.                             LA_Chars,    20,
  556.                             LA_ID,        GAD_SCREENMODE,
  557.                             GTTX_Text,    ModeName,
  558.                             GTTX_Border,    TRUE,
  559.                             LATX_Picker,    TRUE,
  560.                             LATX_LockSize,    TRUE,
  561.                         TAG_DONE);
  562.  
  563.                         LT_EndGroup(Handle);
  564.                     }
  565.  
  566.                     LT_EndGroup(Handle);
  567.                 }
  568.  
  569.                 LT_New(Handle,
  570.                     LA_Type,    VERTICAL_KIND,
  571.                 TAG_DONE);
  572.                 {
  573.                     if(Config -> CaptureConfig -> SearchHistory < 1)
  574.                         Config -> CaptureConfig -> SearchHistory = 10;
  575.  
  576.                     LT_New(Handle,
  577.                         LA_LabelID,        MSG_CAPTUREPANEL_SEARCH_HISTORY_GAD,
  578.                         LA_Type,        INTEGER_KIND,
  579.                         LA_ID,            GAD_SEARCH_HISTORY,
  580.                         LA_Chars,        8,
  581.                         LAIN_UseIncrementers,    TRUE,
  582.                         LAIN_Min,        1,
  583.                         LAIN_Max,        255,
  584.                         LA_BYTE,        &Config -> CaptureConfig -> SearchHistory,
  585.                     TAG_DONE);
  586.  
  587.                     LT_EndGroup(Handle);
  588.                 }
  589.  
  590.                 LT_EndGroup(Handle);
  591.             }
  592.  
  593.             LT_New(Handle,
  594.                 LA_Type,    VERTICAL_KIND,
  595.             TAG_DONE);
  596.             {
  597.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  598.  
  599.                 LT_EndGroup(Handle);
  600.             }
  601.  
  602.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  603.                 LAGR_SameSize,    TRUE,
  604.                 LAGR_Spread,    TRUE,
  605.             TAG_DONE);
  606.             {
  607.                 LT_New(Handle,
  608.                     LA_Type,    BUTTON_KIND,
  609.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  610.                     LA_ID,        GAD_USE,
  611.                     LABT_ReturnKey,    TRUE,
  612.                     LABT_ExtraFat,    TRUE,
  613.                 TAG_DONE);
  614.  
  615.                 if(Default)
  616.                 {
  617.                     LT_New(Handle,
  618.                         LA_Type,    BUTTON_KIND,
  619.                         LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  620.                         LA_ID,        GAD_DEFAULT,
  621.                         LABT_ExtraFat,    TRUE,
  622.                     TAG_DONE);
  623.                 }
  624.  
  625.                 LT_New(Handle,
  626.                     LA_Type,    BUTTON_KIND,
  627.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  628.                     LA_ID,        GAD_CANCEL,
  629.                     LABT_EscKey,    TRUE,
  630.                     LABT_ExtraFat,    TRUE,
  631.                 TAG_DONE);
  632.  
  633.                 LT_EndGroup(Handle);
  634.             }
  635.  
  636.             LT_EndGroup(Handle);
  637.         }
  638.  
  639.         if(PanelWindow = LT_Build(Handle,
  640.             LAWN_TitleID,        MSG_CAPTUREPANEL_CAPTURE_SETTINGS_TXT,
  641.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  642.             LAWN_HelpHook,        &GuideHook,
  643.             LAWN_Parent,        Window,
  644.             WA_DepthGadget,        TRUE,
  645.             WA_CloseGadget,        TRUE,
  646.             WA_DragBar,        TRUE,
  647.             WA_RMBTrap,        TRUE,
  648.             WA_Activate,        TRUE,
  649.             WA_SimpleRefresh,    TRUE,
  650.         TAG_DONE))
  651.         {
  652.             struct IntuiMessage    *Message;
  653.             BOOLEAN             Done = FALSE;
  654.             ULONG             MsgClass;
  655.             struct Gadget        *MsgGadget;
  656.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  657.                         *DummyChar;
  658.             struct FileRequester    *FileRequest;
  659.  
  660.             GuideContext(CONTEXT_CAPTURE);
  661.  
  662.             PushWindow(PanelWindow);
  663.  
  664.             LT_ShowWindow(Handle,TRUE);
  665.  
  666.             do
  667.             {
  668.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  669.                 {
  670.                     SaveConfig(PrivateConfig,Config);
  671.  
  672.                     break;
  673.                 }
  674.  
  675.                 while(Message = LT_GetIMsg(Handle))
  676.                 {
  677.                     MsgClass    = Message -> Class;
  678.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  679.  
  680.                     LT_ReplyIMsg(Message);
  681.  
  682.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  683.                     {
  684.                         SaveConfig(PrivateConfig,Config);
  685.  
  686.                         Done = TRUE;
  687.                     }
  688.  
  689.                     if(MsgClass == IDCMP_GADGETUP)
  690.                     {
  691.                         switch(MsgGadget -> GadgetID)
  692.                         {
  693.                             case GAD_CAPTURE_FILTER:
  694.  
  695.                                 LT_SetAttributes(Handle,GAD_CONVERT_CHARS,
  696.                                     GA_Disabled,    !Config -> CaptureConfig -> CaptureFilterMode,
  697.                                 TAG_DONE);
  698.  
  699.                                 break;
  700.  
  701.                             case GAD_USE:
  702.  
  703.                                 LT_UpdateStrings(Handle);
  704.  
  705.                                 Config -> CaptureConfig -> OpenBufferWindow = OpenBufferWindow;
  706.                                 Config -> CaptureConfig -> OpenBufferScreen = OpenBufferScreen;
  707.                                 Config -> CaptureConfig -> BufferScreenMode = DisplayMode;
  708.  
  709.                                 Done = TRUE;
  710.                                 break;
  711.  
  712.                             case GAD_CANCEL:
  713.  
  714.                                 SaveConfig(PrivateConfig,Config);
  715.  
  716.                                 Cancel = Done = TRUE;
  717.                                 break;
  718.  
  719.                             case GAD_DEFAULT:
  720.  
  721.                                 *Default = TRUE;
  722.  
  723.                                 Done = TRUE;
  724.                                 break;
  725.  
  726.                             case GAD_LOGFILE:
  727.                             case GAD_CALL_LOGFILE:
  728.  
  729.                                 FindPath(PanelWindow,LT_GetString(Handle,MsgGadget -> GadgetID),TRUE,NULL);
  730.                                 break;
  731.  
  732.                             case GAD_BUFFER_PATH:
  733.                             case GAD_CAPTURE_PATH:
  734.  
  735.                                 FindDrawer(PanelWindow,LT_GetString(Handle,MsgGadget -> GadgetID),TRUE,NULL);
  736.                                 break;
  737.                         }
  738.                     }
  739.  
  740.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  741.                     {
  742.                         switch(MsgGadget -> GadgetID)
  743.                         {
  744.                             case GAD_LOGFILE:
  745.  
  746.                                 LT_LockWindow(PanelWindow);
  747.  
  748.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  749.  
  750.                                 if(DummyBuffer[0])
  751.                                 {
  752.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  753.                                         DummyBuffer[0] = 0;
  754.                                     else
  755.                                     {
  756.                                         DummyChar = PathPart(DummyBuffer);
  757.  
  758.                                         *DummyChar = 0;
  759.                                     }
  760.  
  761.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  762.                                 }
  763.                                 else
  764.                                     DummyChar = "";
  765.  
  766.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  767.                                 {
  768.                                     FindPath(PanelWindow,DummyBuffer,TRUE,NULL);
  769.  
  770.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  771.  
  772.                                     FreeAslRequest(FileRequest);
  773.                                 }
  774.  
  775.                                 LT_UnlockWindow(PanelWindow);
  776.                                 break;
  777.  
  778.                             case GAD_CALL_LOGFILE:
  779.  
  780.                                 LT_LockWindow(PanelWindow);
  781.  
  782.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  783.  
  784.                                 if(DummyBuffer[0])
  785.                                 {
  786.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  787.                                         DummyBuffer[0] = 0;
  788.                                     else
  789.                                     {
  790.                                         DummyChar = PathPart(DummyBuffer);
  791.  
  792.                                         *DummyChar = 0;
  793.                                     }
  794.  
  795.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  796.                                 }
  797.                                 else
  798.                                     DummyChar = "";
  799.  
  800.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_CALL_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  801.                                 {
  802.                                     FindPath(PanelWindow,DummyBuffer,TRUE,NULL);
  803.  
  804.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  805.  
  806.                                     FreeAslRequest(FileRequest);
  807.                                 }
  808.  
  809.                                 LT_UnlockWindow(PanelWindow);
  810.                                 break;
  811.  
  812.                             case GAD_BUFFER_PATH:
  813.  
  814.                                 LT_LockWindow(PanelWindow);
  815.  
  816.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  817.  
  818.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_BUFFER_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  819.                                 {
  820.                                     FindDrawer(PanelWindow,DummyBuffer,TRUE,NULL);
  821.  
  822.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  823.  
  824.                                     FreeAslRequest(FileRequest);
  825.                                 }
  826.  
  827.                                 LT_UnlockWindow(PanelWindow);
  828.                                 break;
  829.  
  830.                             case GAD_CAPTURE_PATH:
  831.  
  832.                                 LT_LockWindow(PanelWindow);
  833.  
  834.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  835.  
  836.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_CAPTURE_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  837.                                 {
  838.                                     FindDrawer(PanelWindow,DummyBuffer,TRUE,NULL);
  839.  
  840.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  841.  
  842.                                     FreeAslRequest(FileRequest);
  843.                                 }
  844.  
  845.                                 LT_UnlockWindow(PanelWindow);
  846.                                 break;
  847.  
  848.                             case GAD_SCREENMODE:
  849.  
  850.                                 LT_LockWindow(PanelWindow);
  851.  
  852.                                 if(SelectDisplayMode(PanelWindow,&DisplayMode,Config))
  853.                                 {
  854.                                     strcpy(ModeName,GetModeName(DisplayMode));
  855.  
  856.                                     LT_SetAttributes(Handle,GAD_SCREENMODE,GTTX_Text,ModeName,TAG_DONE);
  857.                                 }
  858.  
  859.                                 LT_UnlockWindow(PanelWindow);
  860.  
  861.                                 LT_ShowWindow(Handle,TRUE);
  862.  
  863.                                 break;
  864.                         }
  865.                     }
  866.                 }
  867.             }
  868.             while(!Done);
  869.  
  870.             PopWindow();
  871.         }
  872.  
  873.         LT_DeleteHandle(Handle);
  874.     }
  875.  
  876.     if(Default)
  877.         return((BYTE)(!Cancel));
  878.     else
  879.         return((BYTE)memcmp(PrivateConfig -> CaptureConfig,Config -> CaptureConfig,sizeof(struct CaptureSettings)));
  880. }
  881.